A software development tool is a software application that software developers use to create, debug, maintain, or otherwise support other software applications or programs. Some examples of types of software development tools include but are not limited to performance analysis tools, debugging tools, static analysis and formal verification tools, correctness checking tools, memory usage tools, application building tools, etc. Some software development tools, such as integrated development environments (IDEs), combine the functionality of multiple types of software development tools into a single comprehensive tool. Such comprehensive tools are often used, among other purposes, to develop enterprise-level applications.
Many modern software development tools enable software developers to manipulate controls (a.k.a. web parts) and/or interact with pieces of content such as lists and documents to create customized solutions. A solution is defined as an application, a program, or an aspect thereof that is created using a software development tool. For example, a declarative language, such as extensible markup language (XML), may be used to generate a package. A package is a file that includes a plurality of other files. For instance, the package may serve essentially as a container for the other files. In accordance with this example, each file in the package includes markup that defines a respective element on which an operation may be performed on a processing system (e.g., a server, a desktop computer, a laptop computer, etc.) for implementing an application or a program. A software developer may use that package as a template and change the markup in the package to create a customized solution.
When a package is selected for importation from a store (e.g., a database), dependencies between elements that are defined by markup in the package are usually resolved in order for an operation to be successfully performed on the package. However, conventional techniques for determining dependencies typically are acyclical, meaning that if element A depends on element B, element B is not allowed to depend on element A. Such interdependency between elements usually results in an infinite loop during performance of an operation, rendering the customized solution unusable.
Moreover, conventional dependency determination techniques often are limited to one-to-one mapping between a single producer of a resource and a single consumer of that resource. For example, if element A produces a resource, and element B consumes the resource, element B is said to depend on element A. In accordance with this example, once the determination is made that element B depends on element A with respect to the resource, conventional dependency determination techniques typically are unable to determine that dependencies exist between element A and elements other than element B that consume the resource or between element B and elements other than element A that produce the resource.
Furthermore, when a software developer uses a package as a template for a customized solution, operations typically are performed on all elements that are defined by markup in the package. For example, conventional dependency determination techniques usually do not allow a software developer to choose whether an operation is performed on elements.